home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / glibmm-2.4 / glibmm / timeval.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-04-20  |  5.4 KB  |  234 lines
  1. // -*- c++ -*-
  2. #ifndef _GLIBMM_TIMEVAL_H
  3. #define _GLIBMM_TIMEVAL_H
  4.  
  5. /* $Id: timeval.h,v 1.1.1.1 2003/01/07 16:58:56 murrayc Exp $ */
  6.  
  7. /* timeval.h
  8.  *
  9.  * Copyright (C) 2002 The gtkmm Development Team
  10.  *
  11.  * This library is free software; you can redistribute it and/or
  12.  * modify it under the terms of the GNU Library General Public
  13.  * License as published by the Free Software Foundation; either
  14.  * version 2 of the License, or (at your option) any later version.
  15.  *
  16.  * This library is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19.  * Library General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU Library General Public
  22.  * License along with this library; if not, write to the Free
  23.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24.  */
  25.  
  26. #include <glib/gtypes.h>
  27. #include <glib/gtimer.h>
  28.  
  29. namespace Glib
  30. {
  31.  
  32. /** Glib::TimeVal is a wrapper around the glib structure GTimeVal.
  33.  * The glib structure GTimeVal itself is equivalent to struct timeval,
  34.  * which is returned by the gettimeofday() UNIX call. Additionally
  35.  * this wrapper provides an assortment of time manipulation functions.
  36.  */
  37. struct TimeVal : public GTimeVal
  38. {
  39.   inline TimeVal();
  40.   inline TimeVal(long seconds, long microseconds);
  41.  
  42.   inline TimeVal(const GTimeVal& gtimeval);
  43.   inline TimeVal& operator=(const GTimeVal& gtimeval);
  44.  
  45.   /** Assigns the current time to the TimeVal instance.
  46.    * Equivalent to the UNIX gettimeofday() function, but is portable and 
  47.    * works also on Win32. 
  48.    */
  49.   void assign_current_time();
  50.  
  51.   void add(const TimeVal& rhs);
  52.   void subtract(const TimeVal& rhs);
  53.   void add_seconds(long seconds);
  54.   void subtract_seconds(long seconds);
  55.   void add_milliseconds(long milliseconds);
  56.   void subtract_milliseconds(long milliseconds);
  57.   void add_microseconds(long microseconds);
  58.   void subtract_microseconds(long microseconds);
  59.  
  60.   inline TimeVal& operator+=(const TimeVal& gtimeval);
  61.   inline TimeVal& operator-=(const TimeVal& gtimeval);
  62.   inline TimeVal& operator+=(long seconds);
  63.   inline TimeVal& operator-=(long seconds);
  64.  
  65.   /** Returns a double representation of the time interval.
  66.    * This member function converts the time interval, that is
  67.    * internally stored as two long values for seconds and microseconds,
  68.    * to a double representation, whose unit is seconds.
  69.    */
  70.   inline double as_double() const;
  71.  
  72.   inline bool negative() const;
  73.  
  74.   /** Checks whether the stored time interval is positive.
  75.    * Returns true if the stored time / time interval is positive.
  76.    */
  77.   inline bool valid() const;
  78. };
  79.  
  80. inline
  81. TimeVal::TimeVal()
  82. {
  83.   tv_sec  = 0;
  84.   tv_usec = 0;
  85. }
  86.  
  87. inline
  88. TimeVal::TimeVal(long seconds, long microseconds)
  89. {
  90.   tv_sec  = seconds;
  91.   tv_usec = microseconds;
  92. }
  93.  
  94. inline
  95. TimeVal::TimeVal(const GTimeVal& gtimeval)
  96. {
  97.   tv_sec  = gtimeval.tv_sec;
  98.   tv_usec = gtimeval.tv_usec;
  99. }
  100.  
  101. inline
  102. TimeVal& TimeVal::operator=(const GTimeVal& gtimeval)
  103. {
  104.   tv_sec  = gtimeval.tv_sec;
  105.   tv_usec = gtimeval.tv_usec;
  106.   return *this;
  107. }
  108.  
  109. inline
  110. TimeVal& TimeVal::operator+=(const TimeVal& gtimeval)
  111. {
  112.   add(gtimeval);
  113.  
  114.   return *this;
  115. }
  116.  
  117. inline
  118. TimeVal& TimeVal::operator-=(const TimeVal& gtimeval)
  119. {
  120.   subtract(gtimeval);
  121.  
  122.   return *this;
  123. }
  124.  
  125. inline
  126. TimeVal& TimeVal::operator+=(long seconds)
  127. {
  128.   add_seconds(seconds);
  129.  
  130.   return *this;
  131. }
  132.  
  133. inline
  134. TimeVal& TimeVal::operator-=(long seconds)
  135. {
  136.   subtract_seconds(seconds);
  137.  
  138.   return *this;
  139. }
  140.  
  141. inline
  142. double TimeVal::as_double() const
  143. {
  144.   return tv_sec + ((double) tv_usec / (double) G_USEC_PER_SEC);
  145. }
  146.  
  147. inline
  148. bool TimeVal::negative() const
  149. {
  150.   return (tv_sec < 0);
  151. }
  152.  
  153. inline
  154. bool TimeVal::valid() const
  155. {
  156.   return (tv_usec >= 0 && tv_usec < G_USEC_PER_SEC);
  157. }
  158.  
  159. /** @relates Glib::TimeVal */
  160. inline
  161. TimeVal operator+(const TimeVal& lhs, const TimeVal& rhs)
  162. { return TimeVal(lhs) += rhs; }
  163.  
  164. /** @relates Glib::TimeVal */
  165. inline 
  166. TimeVal operator+(const TimeVal& lhs, long seconds)
  167. { return TimeVal(lhs) += seconds; }
  168.  
  169. /** @relates Glib::TimeVal */
  170. inline 
  171. TimeVal operator-(const TimeVal& lhs, const TimeVal& rhs)
  172. { return TimeVal(lhs) -= rhs; }
  173.  
  174. /** @relates Glib::TimeVal */
  175. inline 
  176. TimeVal operator-(const TimeVal& lhs, long seconds)
  177. { return TimeVal(lhs) -= seconds; }
  178.  
  179.  
  180. /** @relates Glib::TimeVal */
  181. inline
  182. bool operator==(const TimeVal& lhs, const TimeVal& rhs)
  183. {
  184.   return (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec == rhs.tv_usec);
  185. }
  186.  
  187. /** @relates Glib::TimeVal */
  188. inline
  189. bool operator!=(const TimeVal& lhs, const TimeVal& rhs)
  190. {
  191.   return (lhs.tv_sec != rhs.tv_sec || lhs.tv_usec != rhs.tv_usec);
  192. }
  193.  
  194. /** @relates Glib::TimeVal */
  195. inline
  196. bool operator<(const TimeVal& lhs, const TimeVal& rhs)
  197. {
  198.   return ((lhs.tv_sec < rhs.tv_sec) ||
  199.           (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec < rhs.tv_usec));
  200. }
  201.  
  202. /** @relates Glib::TimeVal */
  203. inline
  204. bool operator>(const TimeVal& lhs, const TimeVal& rhs)
  205. {
  206.   return ((lhs.tv_sec > rhs.tv_sec) ||
  207.           (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec > rhs.tv_usec));
  208. }
  209.  
  210. /** @relates Glib::TimeVal */
  211. inline
  212. bool operator<=(const TimeVal& lhs, const TimeVal& rhs)
  213. {
  214.   return ((lhs.tv_sec < rhs.tv_sec) ||
  215.           (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec <= rhs.tv_usec));
  216. }
  217.  
  218. /** @relates Glib::TimeVal */
  219. inline
  220. bool operator>=(const TimeVal& lhs, const TimeVal& rhs)
  221. {
  222.   return ((lhs.tv_sec > rhs.tv_sec) ||
  223.           (lhs.tv_sec == rhs.tv_sec && lhs.tv_usec >= rhs.tv_usec));
  224. }
  225.  
  226. } // namespace Glib
  227.  
  228.  
  229. #endif /* _GLIBMM_TIMEVAL_H */
  230.  
  231.  
  232.  
  233.  
  234.